/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package br.ufrn.dca.scontrol.control;

import br.ufrn.dca.controle.QuanserClient;
import br.ufrn.dca.controle.QuanserClientException;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jfree.data.xy.XYSeries;

/**
 *
 * @author marco
 */
public class ListenerTanque implements ActionListener {
    QuanserClient qClient;
    double valorColuna;
    double valorTensaoInicial;
    double valorPasso;
    double valorCorrenteT1;
    double valorCorrenteT2;    
    double valorOffsetT1;
    double valorOffsetT2;
    long tempoInicial;
    boolean tInicialSetado;
    long tempoFinal;
    boolean escrito;
    boolean tFinalSetado;
    XYSeries series;
    Vector valoresTensaoT1;
    Vector valoresTensaoT2;
    Vector valoresTempo;
    private int counter;
    Vector tensoesAplicadas;
    private boolean deixaContar;

    public boolean istInicialSetado() {
        return tInicialSetado;
    }

    public void settInicialSetado(boolean tInicialSetado) {
        this.tInicialSetado = tInicialSetado;
    }

    public long getTempoInicial() {
        return tempoInicial;
    }

    public void setTempoInicial(long tempoInicial) {
        this.tempoInicial = tempoInicial;
    }

    public boolean istFinalSetado() {
        return tFinalSetado;
    }

    public void settFinalSetado(boolean tFinalSetado) {
        this.tFinalSetado = tFinalSetado;
    }

    public long getTempoFinal() {
        return tempoFinal;
    }

    public void setTempoFinal(long tempoFinal) {
        this.tempoFinal = tempoFinal;
    }

    public double getValorOffsetT1() {
        return valorOffsetT1;
    }

    public void setValorOffsetT1(double valorOffsetT1) {
        this.valorOffsetT1 = valorOffsetT1;
    }

    public double getValorOffsetT2() {
        return valorOffsetT2;
    }

    public void setValorOffsetT2(double valorOffsetT2) {
        this.valorOffsetT2 = valorOffsetT2;
    }

    public QuanserClient getqClient() {
        return qClient;
    }

    public void setqClient(QuanserClient qClient) {
        this.qClient = qClient;
    }

    public double getValorColuna() {
        return valorColuna;
    }

    public void setValorColuna(double valorColuna) {
        this.valorColuna = valorColuna;
    }

    public double getValorPasso() {
        return valorPasso;
    }

    public void setValorPasso(double valorPasso) {
        this.valorPasso = valorPasso;
    }

    public double getValorTensaoInicial() {
        return valorTensaoInicial;
    }

    public void setValorTensaoInicial(double valorTensaoInicial) {
        this.valorTensaoInicial = valorTensaoInicial;
    }
    public ListenerTanque(){
        try{
            valoresTempo = new Vector();
            valoresTensaoT1 = new Vector();
            valoresTensaoT2 = new Vector();
            //qClient = new QuanserClient("10.13.99.69",20081);
            qClient = new QuanserClient("127.0.0.1",20081);
            escrito = false;
            series = new XYSeries("Tanque 1");
            counter=0;
            tensoesAplicadas = new Vector();
            deixaContar = true;
            tInicialSetado = false;
        }catch(QuanserClientException ex){
            ex.printStackTrace();
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        try {
            double valueT1 = (double) 0.00;
            double valueT2 = (double) 0.00;
            double limite1 = (double) 4.32;
            double limite2 = (double) 4.32;
            
            //seta o tempo inicial
            if(!tInicialSetado){
                tempoInicial = System.currentTimeMillis();
                tInicialSetado = true;
            }

            setValorCorrenteT1((double)qClient.read(0));
            setValorCorrenteT2((double)qClient.read(1));

            //esvaziou o tanque
            if(istFinalSetado() && (getValorCorrenteT1()+getValorOffsetT1())<=getValorOffsetT1()){
                if(counter<=getTensoesAplicadas().size()){
                    settFinalSetado(false);
                    setEscrito(false);
                    deixaContar = true;
                }
            }

            //verificar se o valor da corrente do tanque 1 é menor que o valor setado de coluna
            if((getValorCorrenteT1()+getValorOffsetT1())<(getValorColuna()/6.25)){
                if((getValorCorrenteT1()+getValorOffsetT1()) < limite1 && (getValorCorrenteT2()+getValorOffsetT2()) < limite2){//setar trava

                    if(!escrito){
                        if(counter<=tensoesAplicadas.size()){
                            qClient.write(0, Double.parseDouble(tensoesAplicadas.get(counter).toString()));                            
                        }
                        if (!istInicialSetado()) {
                            setTempoInicial(System.currentTimeMillis());
                            settInicialSetado(true);
                        }
                        
                        escrito = true;
                    }

                    setValorCorrenteT1((double)qClient.read(0));
                    setValorCorrenteT2((double)qClient.read(1));

                    long tempo = System.currentTimeMillis();
                    valoresTensaoT1.add(getValorCorrenteT1());
                    valoresTensaoT2.add(getValorCorrenteT2());
                    valoresTempo.add(tempo);
                    //Number tm = (Number)((tempo - valoresTempo.get(valoresTempo.size()-1))/1000);
                    series.add(Double.parseDouble(valoresTempo.get(valoresTempo.size()-1).toString()),
                            Double.parseDouble(valoresTensaoT1.get(valoresTensaoT1.size()-1).toString()));//((double)(tempo - valoresTempo.get(valoresTempo.size()))/1000), getValorCorrenteT1());
                    //System.out.println("Tempo: "+tempo+" Corrente: "+(getValorCorrenteT1()+getValorOffsetT1()));
                }else{                    
                    qClient.write(0, (double)0.00);
                }
            }else{
                    if(!istFinalSetado()){
                        Long tempoFinall = System.currentTimeMillis();
                        setTempoFinal(tempoFinall);
                        settFinalSetado(true);
                        System.out.println("FINAL____________________________________:   "+getTempoFinal()+" "+getTempoInicial()+" "+(getTempoFinal()-getTempoInicial()));
                    }
                    if(deixaContar){
                        counter++;//contador
                        deixaContar = false;
                    }
                    qClient.write(0, (double)0.00);
            }
        } catch (QuanserClientException ex) {
            Logger.getLogger(ListenerTanque.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void killClient(){
        try{
            qClient.write(0, (double)0.00);
        }catch(QuanserClientException e){
            System.out.println("Problemas em matar o cliente Quanser");
        }
    }

    public double getValorCorrenteT1() {
        return valorCorrenteT1;
    }

    public void setValorCorrenteT1(double valorCorrenteT1) {
        this.valorCorrenteT1 = valorCorrenteT1;
    }

    public double getValorCorrenteT2() {
        return valorCorrenteT2;
    }

    public void setValorCorrenteT2(double valorCorrenteT2) {
        this.valorCorrenteT2 = valorCorrenteT2;
    }

    public void takeOffsetValues(){
        try{
            //QuanserClient q = new QuanserClient("10.13.99.69",20081);
            QuanserClient q = new QuanserClient("127.0.0.1",20081);
            setValorOffsetT1(Math.abs((double) qClient.read(0)));
            setValorOffsetT2(Math.abs((double) qClient.read(1)));
            q.disconnect();
        }catch(QuanserClientException ex){
            System.out.println("Problema de conexão");
        }
    }

    public boolean isEscrito() {
        return escrito;
    }

    public void setEscrito(boolean escrito) {
        this.escrito = escrito;
    }

    public Vector getValoresTempo() {
        return valoresTempo;
    }

    public Vector getValoresTensaoT1() {
        return valoresTensaoT1;
    }

    public Vector getValoresTensaoT2() {
        return valoresTensaoT2;
    }

    public XYSeries getSeries() {
        return series;
    }

    public void setSeries(XYSeries series) {
        this.series = series;
    }

    public Vector getTensoesAplicadas() {
        return tensoesAplicadas;
    }

    //seta todas as tensoes aplicadas nos testes
    public void setTensoesAplicadas(Vector tensoesAplicadas) {
        this.tensoesAplicadas = tensoesAplicadas;
    }

    public int getCounter() {
        return counter;
    }

    public void setCounter(int counter) {
        this.counter = counter;
    }
    
}